﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Arrays
{
    class Program
    {
        static void Main(string[] args)
        {
            //Cоздание двумерного массива
            //MaxValue();
            //ValueCountDiffFromMin();
            //FindSumBeforeMaxValue();
            //IndexOfLastNegativeNumber();
            //ReplaceElementsByAverageValue();

            //int[,] intArray = new int[3, 4];
            //Random rnd = new Random();
            //for (int i = 0; i < 3; i++)
            //{

            //    for (int j = 0; j < 4; j++)
            //    {
            //        intArray[i, j] = rnd.Next(10);
            //        Console.Write("{0}\t", intArray[i, j]);
            //    }
            //    Console.WriteLine();
            //}
            //ReplaceFifthElement();

            Console.Write("Введите кол-во строк: ");
            int rows = Int32.Parse(Console.ReadLine());
            Console.Write("Введите кол-во столбцов: ");
            int columns = Int32.Parse(Console.ReadLine());

            //FirstTask(rows,columns);
            //SecondTask(columns, rows);
            //ThirdTask(rows, columns);
            FourthTask(rows, columns);
            Console.ReadKey();
            
        }

        //1. Создать массив - размеры массива выбирает пользователь из консоли.
        //Заполнить массив случайными числами в диапазоне от 1 до 20. Вывести полученный массив на экран.
        //Посчитать количество четных и нечетных элементов в массиве
        static void FirstTask(int rows, int columns)
        {
            int[,] testArray = FillArrayWithRandom(rows, columns, 0, 20);
            PrintArrayToConsole(testArray);

            int chetnye = 0;
            int nechetnye = 0;
            int value;
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    value = testArray[i, j];
                    if ((value % 2) == 0)
                    {
                        chetnye++;
                    }
                    else nechetnye++;
                }
            }
            Console.WriteLine("Количество нечетных элементов: {0}", nechetnye);
            Console.WriteLine("Количество четных элементов: {0}", chetnye);
            Console.ReadKey();
        }

        //2) Создается массив из n строк и m столбцов.Найти: максимальный из наименьших элементов столбцов.
        static void SecondTask(int columns, int rows)
        {
            int maxValue;
            int[,] testArray = FillArrayWithRandom(rows, columns, 0, 20);
            PrintArrayToConsole(testArray);
            int[] minValueArray = new int[columns];

            for (int j = 0; j<columns; j++)
                {
                    int minValue = Int32.MaxValue;
                    for (int i = 0; i<rows; i++)
                        { 
                        if (testArray[i, j] < minValue)
                        {
                            minValue = testArray[i, j];
                        }
                        }
                minValueArray[j] = minValue;
                }
            maxValue = minValueArray.Max();
            Console.WriteLine("Mаксимальный из наименьших элементов столбцов; {0}", maxValue);
            Console.ReadKey();
        }

        //3) Создать двумерный массив, заполненный случайными числами. 
        //После заполнения — показать заполненный массив на экран и посчитать сумму элементов отдельно в каждом столбце и каждой строке.
        static void ThirdTask(int rows, int columns)
        {
            int columnSum = 0;
            int rowSum = 0;
            int[,] testArray = FillArrayWithRandom(rows, columns, 0, 20);
            PrintArrayToConsole(testArray);
            for (int i = 0; i < rows; i++)
            {
                rowSum = 0;
                for (int j = 0; j < columns; j++)
                {
                    rowSum = rowSum + testArray[i, j];

                }
                Console.WriteLine("Cумма элементов [{0}] строки\t {1}", i, rowSum);
            }
            Console.WriteLine();
            for (int j = 0; j < columns; j++)
            {
                columnSum = 0;
                for (int i = 0; i < rows; i++)
                {
                    columnSum = columnSum + testArray[i, j];
                }
                Console.WriteLine("Cумма элементов [{0}] столбца\t {1}", j, columnSum);
            }
            Console.ReadKey();
        }

        //4) Заполнить двумерный массив случайными числами от 10 до 100. 
        //Посчитать сумму элементов отдельно в каждой строке и определить номер строки, в которой эта сумма максимальна.
        static void FourthTask(int rows, int columns)
        {
            int[,] testArray = FillArrayWithRandom(rows, columns, 9, 100);
            PrintArrayToConsole(testArray);
            int sum;
            int maxValue=0;
            int indexOfMaxValue=0;
            int[] rowsSumArray = new int[rows];
            for (int i=0; i<rows;i++)
            {
                sum = 0;
                for (int j = 0; j < columns; j++)
                {
                    sum = sum + testArray[i, j];
                }
                rowsSumArray [i] = sum;
            }
            maxValue = rowsSumArray.Max();
            indexOfMaxValue = Array.IndexOf(rowsSumArray, maxValue);

            Console.WriteLine("Сумма:");
            PrintIntArray(rowsSumArray);
            Console.WriteLine("Номер строки с максимальной суммой элементов - {0}.", indexOfMaxValue);

        }

        static int [,] FillArrayWithRandom (int rowSize, int columnSize, int minValue, int maxValue)   //создание рендомного двумерного массива
        {
            int[,] array = new int[rowSize, columnSize];
            Random rnd = new Random();
            for (int i=0; i<rowSize; i++)
            {
                for (int j=0; j<columnSize; j++)
                {
                    array[i, j] = rnd.Next(minValue, maxValue+1);
                }
            }
            return array;
        }

        static void PrintArrayToConsole(int [,] arrayForPrint)      //печать двумерного массива
        {
            for (int i = 0; i<arrayForPrint.GetLength(0); i++)
            {
                for (int j = 0; j<arrayForPrint.GetLength(1); j++)
                {
                    Console.Write("{0}\t", arrayForPrint[i, j]);
                }
                Console.WriteLine();
            }
            //Console.ReadLine();
        }
        
        static int MaxElementFromArray (int[] array)   //implemented instead of if into MaxValue method
        {
            int maxValue = 0;
            foreach (var item in array)
            {
                if (item > maxValue)
                {
                    maxValue = item;
                }
            }
            return maxValue;
        }

        static int[] FillArrayFromConsole(int arraySize)   // implemented into ValueCountDiffFromMin method
        {
            int[] array = new int[arraySize];
            for (int i = 0; i < arraySize; i++)
            {
                Console.Write("[{0}]: ", i);
                array[i] = Int32.Parse(Console.ReadLine());
            }
            return array;
        }

        static void PrintIntArray(int[] array)   //implemented into ReplaceElementsByAverageValue method
        {
            Console.WriteLine("Элементы массива: ");
            foreach (int number in array)
            {
                Console.WriteLine(number);
            }
        }

        static void PrintArray(double[] array)   //implemented into ReplaceElementsByAverageValue method
        {
            Console.WriteLine("Элементы массива: ");
            foreach (double number in array)
            {
                Console.WriteLine(number);
            }
        }

        static void ReplaceFifthElement()
        {
            int[,] newArray = FillArrayWithRandom(4, 5, 0, 10);
            PrintArrayToConsole(newArray);

            int sum;
            for (int i=0; i<4; i++)
            {
                sum = 0;
                for (int j = 0; j < 5; j++)
                    {
                    //sum = sum + newArray[i, j];
                    if (j == 4)
                        newArray[i, j] = sum;
                    else
                        sum = sum + newArray[i, j];
                    }
            }
            PrintArrayToConsole(newArray);


        }

        static void MaxValue()
        {
            //Пользователь вводит массив из 5 элементов.Найти максимальный элемент массива. Вывести на экран элементы массива и максимум.
            Console.WriteLine("Ввeдите массив из 5-ти элементов: ");

            //int maxValue = 0;
            int[] intArray = new int[5];
            for (int i = 0; i < 5; i++)
            {
                Console.Write("[{0}]: ", i);
                intArray[i] = Int32.Parse(Console.ReadLine());
            }
            Console.WriteLine("Элементы массива intArray: ", intArray);

            Console.WriteLine("Введенныe элементы: ");
            foreach (var item in intArray)
            {
                Console.WriteLine(item);

                //if (item > maxValue)
                //{
                //    maxValue = item;
                //}
            }
            Console.WriteLine("Максимальный элемент массива: {0}", MaxElementFromArray(intArray));
            Console.ReadKey();
        }

        //Определить количество элементов в заданном массиве, отличающихся от минимального элемента массива на 5. Размер массива пользователь вводит в консоли
        static void ValueCountDiffFromMin()
        {
            Console.WriteLine("Введите размерность массива:");
            int elementsCount = Int32.Parse(Console.ReadLine());
            Console.WriteLine("Ввeдите массив из {0} элементов: ", elementsCount);

            int[] intArray = FillArrayFromConsole(elementsCount);
            int minValue;
            
            minValue = intArray.Min();
            minValue = minValue + 5;
            int count=0;
            for (int i = 0; i < elementsCount; i++)
            {
                if (intArray[i] == minValue)
                {
                    count++;
                }
            }
            Console.WriteLine("Kоличество элементов в заданном массиве, отличающихся от минимального элемента массива на 5: {0}", count);
            Console.ReadKey();
        }

        //Дан одномерный массив, размер массива задается пользователем из консоли. 
        //Найти сумму элементов, расположенных до максимального элемента массива. 
        //Если максимальных элементов несколько - то найти сумму элементов до первого максимального элемента. 
        //Если максимальный элемент первый в массиве - то сумма равна 0
        static void FindSumBeforeMaxValue()
        {
            Console.WriteLine("Введите размерность массива:");
            int elementsCount = Int32.Parse(Console.ReadLine());
            Console.WriteLine("Ввeдите массив из {0} элементов: ", elementsCount);
            int[] intArray = new int[elementsCount];
            for (int i = 0; i < elementsCount; i++)
            {
                Console.Write("[{0}]: ", i);
                intArray[i] = Int32.Parse(Console.ReadLine());
            }
            int maxValue;
            maxValue = intArray.Max();
            int sum=0;
            int elementValue;
            for (int i = 0; i < elementsCount; i++)
            {
                elementValue = intArray[i];
                if (elementValue<maxValue)
                {
                    sum = sum + elementValue;
                }
                if (elementValue==maxValue)
                {
                    Console.WriteLine("Cуммa элементов, расположенных до максимального элемента массива - {0}", sum);
                }
            }
            Console.ReadKey();
        }

        //4) Определить значение и номер последнего отрицательного элемента массива размером 8. 
        //Если отрицательных элементов нет - вывести соответствующее сообщение.
        static void IndexOfLastNegativeNumber()
        {
            Console.WriteLine("Ввeдите массив из 8-ми элементов: ");

            int[] intArray = new int[8];
            for (int i = 0; i < 8; i++)
            {
                Console.Write("[{0}]: ", i);
                intArray[i] = Int32.Parse(Console.ReadLine());
            }

            int indexOfValue = 0;
            int elementValue = 0;
            int finalValue = 0;
            for (int i=0; i<8; i++)
            {
                elementValue = intArray[i];
                if (elementValue < 0)
                {
                    indexOfValue = i;
                    finalValue = intArray[i];
                }
                else if (finalValue == 0)
                {
                    Console.WriteLine("Все элементы положительные.");
                    Console.ReadKey();
                    return;
                }
            }
            Console.WriteLine("Номер последнего негативного элемента: {0}", indexOfValue);
            Console.WriteLine("Значение последнего отрицательно элемента массива равно {0}", finalValue);
            Console.ReadKey();
        }

        //5) В одномерном массиве все элементы, расположенные после максимального, заменить средним значением элементов массива. 
        //Вывести обновленный массив на экран. Размер массива указывается пользователем

        static void ReplaceElementsByAverageValue()
        {
            Console.WriteLine("Введите размерность массива:");
            int elementsCount = Int32.Parse(Console.ReadLine());
            Console.WriteLine("Ввeдите массив из {0} элементов: ", elementsCount);
            int[] intArray = new int[elementsCount];
            for (int i = 0; i < elementsCount; i++)
            {
                Console.Write("[{0}]: ", i);
                intArray[i] = Int32.Parse(Console.ReadLine());
            }

            int maxValue;
            int elementValue = 0;
            double avaregeValue = 0;
            int sum = 0;
            maxValue = intArray.Max();
            int indexOfMaxValue = Array.IndexOf(intArray, maxValue);

            for (int i = 0; i < elementsCount; i++)
            {
                elementValue = intArray[i];
                sum += elementValue;
            }
            avaregeValue = (double)sum / elementsCount;

            double[] resultArray = new double[elementsCount];
            Array.Copy(intArray, 0, resultArray, 0, indexOfMaxValue + 1);
            for (int j = indexOfMaxValue + 1; j < elementsCount; j++)
            {
                resultArray[j] = Math.Round(avaregeValue, 2);
            }

            PrintArray(resultArray);
            Console.ReadKey();
        }
    }
}
